﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using CruzDelSur.Models;
using CruzDelSur.Dominio;
using CruzDelSur.Dominio.Seguridad;
using CruzDelSur.Persistencia;
using System.Web.Mvc;
using System.Data.SqlTypes;
using System.Globalization;

namespace CruzDelSur.Negocio
{
    public class ServiciosService
    {
        //IoC
        IServicioDAO ServicioDAO { get; set; }
        IParametroDAO ParametroDAO { get; set; }
        ITramoDAO TramoDAO { get; set; }
        IUbicacionDAO UbicacionDAO { get; set; }
        IServicioTramoDAO ServicioTramoDAO { get; set; }
        public ReporteServiciosDAO ReporteServiciosDAO { get; set; }
        public ServiciosService() {
            ReporteServiciosDAO = new ReporteServiciosDAO();
        }
        /// <summary>
        /// Retorna una lista de servicios
        /// </summary>
        public ICollection<Servicio> listarServicios()
        {
            return ServicioDAO.ListarServicios();
        }

        public ICollection<Tramo> listarTramos()
        {
             return TramoDAO.ListarTramos();
        }

        public ICollection<Ubicacion> listarUbicaciones()
        {
            return UbicacionDAO.ListarUbicaciones();
        }        /// <summary>
        /// Buscar un Servicio existente desde el código
        /// de servicio
        /// </summary>
        /// <param name="Codigo">Codigo de servicio</param>
        public Servicio obtenerServicio(string Codigo)
        {
            return ServicioDAO.Obtener(Codigo);
        }
        /// <summary>
        /// Devuelve el formato de la fecha según la Configuración regional del sistema
        /// </summary>
        public string formatoFecha()
        {
            string format = CultureInfo.CurrentCulture.DateTimeFormat.ShortDatePattern.ToLower();
            return format.Replace("yyyy", "yy");
        }

        /// <summary>
        /// Crea un nuevo servicio y los asocia con los tramos
        /// </summary>
        /// <param name="toServicio">Clase de dominio Servicio</param>
        /// <param name="tramos">Colección de tramos del modelo FilaTramo </param>
        /// <returns></returns>
        public Servicio crearServicio(Servicio toServicio, ICollection<IFilaTramoModel> tramos)
        {
            if (toServicio.Codigo.Equals(""))
            {
                throw new CodigoInvalidoException("Debe ingresar un código válido");
            }
            if (ServicioDAO.Obtener(toServicio.Codigo) != null)
            {
                throw new ServicioExistenteException("Código ya existe");
            }

            if (toServicio.Caracteristicas.Count == 0)
            {
                throw new DatoInvalidoException("Debe ingresar por lo menos una característica");
            }

            if (String.IsNullOrEmpty(toServicio.Descripcion))
            {
                throw new DatoInvalidoException("Debe ingresar la descripción");
            }

            toServicio.Estado = Servicio.PENDIENTE;
            toServicio.FechaCreacion = DateTime.Now;
            toServicio.FechaModificacion = DateTime.Now;
            ServicioDAO.Crear(toServicio);
            guardarServicioTramo(toServicio, tramos);
            return toServicio;
        }

        public ServiciosModel crearServicio(ServiciosModel moServicio)
        {
            if (moServicio.EstadoEdicion != ServicioEstadoEnum.NUEVO)
            {
                throw new CodigoInvalidoException("Operación inválida");
            }
            this.crearServicio(moServicio.Servicio, moServicio.FilasTramos);
            return moServicio;
        }
        /// <summary>
        /// Actualiza los datos de un servicio permitiendo darle de baja, como dar de baja a 
        /// tramos individualmente
        /// </summary>
        /// <param name="moServicio">Domiino Servicio</param>
        /// <param name="tramos">Coleccion de tramos</param>
        /// <returns></returns>
        public Servicio modificarServicio(Servicio moServicio, ICollection<IFilaTramoModel> tramos)
        {
            if (moServicio.Codigo.Equals(""))
            {
                throw new CodigoInvalidoException("Debe ingresar un código válido");
            }

            if (String.IsNullOrEmpty(moServicio.Descripcion))
            {
                throw new DatoInvalidoException("Debe ingresar la descripción");
            }

            if (moServicio.Caracteristicas.Count == 0)
            {
                throw new DatoInvalidoException("Debe ingresar por lo menos una característica");
            }

            Servicio edServicio = ServicioDAO.Obtener(moServicio.Codigo);
            edServicio.Caracteristicas = moServicio.Caracteristicas;
            edServicio.Descripcion = moServicio.Descripcion;
            edServicio.FechaModificacion = DateTime.Now;
            edServicio.UsuarioModificado = moServicio.UsuarioModificado;
            guardarServicioTramo(moServicio, tramos);
            if (edServicio.FechaCreacion == DateTime.MinValue) edServicio.FechaCreacion = SqlDateTime.MinValue.Value;
            if (edServicio.FechaBaja == DateTime.MinValue) edServicio.FechaBaja = SqlDateTime.MinValue.Value;
            moServicio = ServicioDAO.Modificar(edServicio);
            return edServicio;
        }
        /// <summary>
        ///  Actualiza los datos de un servicio permitiendo darle de baja, como dar de baja a 
        /// tramos individualmente
        /// </summary>
        /// <param name="moServicio">Modelo Servicio</param>
        /// <returns></returns>
        public ServiciosModel modificarServicio(ServiciosModel moServicio)
        {
            if (moServicio.EstadoEdicion == ServicioEstadoEnum.NUEVO)
            {
                throw new CodigoInvalidoException("Operación inválida");
            }
            this.modificarServicio(moServicio.Servicio, moServicio.FilasTramos);
            return moServicio;
        }
        /// <summary>
        /// guardarServicioTramo
        /// </summary>
        /// <param name="moServicio"></param>
        /// <param name="tramos"></param>
        private void guardarServicioTramo(Servicio moServicio, ICollection<IFilaTramoModel> tramos)
        {
            foreach (var r in tramos)
            {
                if (r.GetType() == typeof(AdicionarFilaTramoModel)) {
                    ServicioTramo st = new ServicioTramo
                    {
                        Estado = Servicio.PENDIENTE,
                        Servicio = moServicio.Codigo,
                        Tramo = r.Tramo.Codigo,
                        FlagServicioTramo = r.esServicioTramo,
                        FechaBaja = SqlDateTime.MinValue.Value,
                        FechaCreacion = DateTime.Now,
                        FechaModificacion = DateTime.Now,
                        UsuarioCreado = moServicio.UsuarioCreado,
                        UsuarioModificado = moServicio.UsuarioModificado
                    };
                    ServicioTramoDAO.Crear(st);
                } else {
                    ServicioTramo st = new ServicioTramo
                    {
                        Servicio = moServicio.Codigo,
                        Tramo = r.Tramo.Codigo,
                        FlagServicioTramo = r.esServicioTramo,
                        FechaBaja = r.Tramo.FechaBaja,
                        FechaCreacion = moServicio.FechaCreacion,
                        FechaModificacion = moServicio.FechaModificacion,
                        UsuarioCreado = moServicio.UsuarioCreado,
                        UsuarioModificado = moServicio.UsuarioModificado
                    };
                    if (r.Tramo.FechaBaja > SqlDateTime.MinValue.Value)
                    {
                        if (!RN_FechaBajaValido(r.Tramo.FechaBaja))
                        {
                            r.Tramo.FechaBaja = SqlDateTime.MinValue.Value;
                            throw new FechaBajaServicioInvalidoException("Las bajas de tramos asociados al servicio, deben tener una fecha de inicio de baja mayor por 2 meses al día que se registra la baja");
                        }
                        ServicioTramoDAO.DarBajaTramo(st);
                    }
                    else
                    {
                        ServicioTramoDAO.ActualizarServicioTramo(st);
                    }
                }
            }
        }
        /// <summary>
        /// Regla de negocio: Valida que lafecha este entre un rango de meses establecido
        /// </summary>
        /// <param name="fecha"></param>
        /// <returns></returns>
        public bool RN_FechaBajaValido(DateTime fecha) {
            return fecha >= DateTime.Now.AddMonths(2);
        }

        /// <summary>
        /// Da de baja a un servicio
        /// </summary>
        /// <param name="codigo"></param>
        /// <param name="fecha"></param>
        /// <param name="user"></param>
        /// <returns></returns>
        public bool darBajaServicio(string codigo, DateTime fecha, Usuario user)
        {
            if (codigo.Trim().Equals(""))
            {
                throw new CodigoInvalidoException("Debe ingresar un código válido");
            }
            //Regla de negocio - SE_RN_12
            if (!this.RN_FechaBajaValido(fecha))
            {
                throw new FechaBajaServicioInvalidoException("Las bajas de servicio deben tener una fecha de inicio de baja mayor por 2 meses al día que se registra la baja");
            }
            Servicio s = ServicioDAO.Obtener(codigo);
            if (s != null)
            {
                ServicioTramoDAO.DarBaja(s.Codigo, s.FechaBaja);
                s.FechaBaja = fecha;
                s.FechaModificacion = DateTime.Now;
                s.UsuarioModificado = user.Codigo;
                s.Estado = Servicio.INACTIVO;
                ServicioDAO.Modificar(s);
            }
            else
            {
                throw new CodigoInvalidoException("Código no existe");
            }
            return true;
        }
        public bool darBajaTramo(Tramo tramo)
        {
            if (tramo.Codigo.Trim().Equals(""))
            {
                throw new CodigoInvalidoException("Debe ingresar un código válido");
            }
            //Regla de negocio - SE_RN_12
            if (!this.RN_FechaBajaValido(tramo.FechaBaja))
            {
                throw new FechaBajaServicioInvalidoException("Las bajas de tramos deben tener una fecha de inicio de baja mayor por 2 meses al día que se registra la baja");
            }
            Tramo t = TramoDAO.Obtener(tramo.Codigo);
            if (t != null)
            {
                t.FechaBaja = tramo.FechaBaja;
                t.FechaModificacion = DateTime.Now;
                t.Estado = Servicio.INACTIVO;
                TramoDAO.Modificar(t);
            }
            else
            {
                throw new CodigoInvalidoException("Código no existe");
            }
            return true;
        }
        /// <summary>
        /// Obtiene un  Combobox de lista de parametros
        /// </summary>
        /// <param name="valores"></param>
        /// <param name="Name"></param>
        /// <param name="Value"></param>
        /// <param name="Selected"></param>
        /// <returns></returns>
        public SelectList parseParametroSelect(ICollection<Parametro> valores, string Name, string  Value, object Selected = null)
        {
            if (valores == null) valores = new List<Parametro>();
            return new SelectList(valores, Name, Value, Selected);
        }
        /// <summary>
        /// Procesa el envio de Submit del formulario de Servicios
        /// </summary>
        /// <param name="model"></param>
        /// <param name="Request"></param>
        /// <param name="user"></param>
        /// <returns></returns>
        public ServiciosModel procesarServiciosModel(ServiciosModel model, HttpRequestBase Request, Usuario user)
        {
            model.Servicio.Caracteristicas = new List<Parametro>();
            model.FilasTramos = new List<IFilaTramoModel>();
            model.Parametros = listaCaracteristicas(model.Servicio.Codigo);
            //Regla de negocio SE_RN_06
            if (Request.Form["Caracteristica"] != null)
            {
                foreach (string p in Request.Form["Caracteristica"].Split(','))
                {
                    Parametro ps = obtenerParametro(p);
                    model.Servicio.Caracteristicas.Add(ps);
                    model.Parametros.Remove(ps);
                }
            }

            if (Request.Form["Tramos[]"] != null)
            {
                foreach (string key in Request.Form["Tramos[]"].Split(','))
                {
                    string fechaBajaTramo = Request.Form["FechaBajaTramo[" + key + "]"];
                    IFilaTramoModel filaTramoItem;
                    if (!string.IsNullOrEmpty(fechaBajaTramo))
                    {
                        filaTramoItem = abrirFilaTramoModel(model.Servicio.Codigo, key, fechaBajaTramo);
                    }
                    else
                    {
                        filaTramoItem = abrirFilaTramoModel(model.Servicio.Codigo, key);
                    }
                    filaTramoItem.esServicioTramo = model.ServicioEspecial;
                    model.FilasTramos.Add(filaTramoItem);
                }
            }
            
            //Flujo básico
            if (model.Servicio.Caracteristicas.Count == 0)
            {
                throw new DatoInvalidoException("Debe registrarse como mínimo una característica del servicio");
            }
            if ( model.FilasTramos.Count == 0) {
                throw new DatoInvalidoException("Debe Seleccionar un tramo");
            }else
            {
                foreach (var t in model.FilasTramos) {
                    if (!t.esModeloValido)
                    {
                        throw new DatoInvalidoException("Fecha ingresada no es válida en tramo: " + t.Tramo.Codigo);
                    }
                }
            }
            if (model.esModeloValido)
            {
                model.Servicio.UsuarioCreado = user.Codigo;
                model.Servicio.UsuarioModificado = user.Codigo;
                if (model.EstadoEdicion == ServicioEstadoEnum.NUEVO)
                {
                    crearServicio(model);//Crear el servicio
                    model.EstadoEdicion = ServicioEstadoEnum.EDITAR;
                }
                else
                {
                    modificarServicio(model);
                }
            }
            return model;
        }
        /// <summary>
        /// Devuelve el Modelo de servicio para que se visualize en el formulario de presentación de Servicios
        /// </summary>
        /// <param name="codServicio"></param>
        /// <param name="estado"></param>
        /// <returns></returns>
        public ServiciosModel actualizarServicioModel(string codServicio, ServicioEstadoEnum estado)
        {
            ServiciosModel model = new ServiciosModel
            {
                Parametros = ParametroDAO.ListarParametros(codServicio),
                EstadoEdicion = estado,
                FilasTramos = obtenerFilaTramo(codServicio),
                ServicioEspecial = ServicioTramoDAO.ObtenerFlagServicioEspecial(codServicio)
            };
            if (estado == ServicioEstadoEnum.EDITAR)
            {
                model.Servicio = obtenerServicio(codServicio);
            }
            return model;
        }
        /// <summary>
        /// Permite dar de baja a un servicio
        /// </summary>
        /// <param name="codServicio"></param>
        /// <param name="estado"></param>
        /// <returns></returns>
        public ServiciosModel darBajaServioModel(string codServicio, ServicioEstadoEnum estado)
        {
            ServiciosModel model = new ServiciosModel
            {
                Servicio = obtenerServicio(codServicio),
                EstadoEdicion = estado,
            };
            model.Servicio.FechaBaja = DateTime.Now.AddMonths(2);
            return model;
        }
        /// <summary>
        /// Devuelve un listado de parametros o características
        /// </summary>
        /// <param name="codigo"></param>
        /// <returns></returns>
        public ICollection<Parametro> listaCaracteristicas(string codigo)
        {
            ICollection<Parametro> parametro = ParametroDAO.Listar();
            if (parametro == null) parametro = new List<Parametro>();
            return parametro;
        }

        public Parametro obtenerParametro(string codigo)
        {
            return ParametroDAO.Obtener(codigo);
        }

        public AdicionarFilaTramoModel nuevoFilaTramoModel(string Codigo)
        {
            AdicionarFilaTramoModel model = new AdicionarFilaTramoModel();
            ICollection<Tramo> items = listarTramos();
            if (Codigo != null)
            {
                model.Tramo = TramoDAO.Obtener(Codigo);
            }
            else
            {
                model.Tramo = items.First();
            }
            model.ComboTramo = new SelectList(items, "Codigo", "Descripcion", Codigo);
            model.esModeloValido = true;
            return model;
        }

        public IFilaTramoModel abrirFilaTramoModel(string codServ, string idTramo)
        {
            Tramo tramo = ServicioTramoDAO.ObtenerTramo(codServ, idTramo);
            if (tramo == null)
            {
                return this.nuevoFilaTramoModel(idTramo);
            } else {
                IFilaTramoModel filaTramoModel = this.editarFilaTramoModel(tramo);
                filaTramoModel.esModeloValido = true;
                return filaTramoModel;
            }
        }

        public IFilaTramoModel abrirFilaTramoModel(string codServ, string idTramo, string fecBaja)
        {
            IFilaTramoModel filaTramoModel = abrirFilaTramoModel(codServ, idTramo);
            try
            {
                filaTramoModel.Tramo.FechaBaja = DateTime.Parse(fecBaja, CultureInfo.CreateSpecificCulture("es-PE"));
                filaTramoModel.esModeloValido = true;
            }
            catch
            {
                filaTramoModel.esModeloValido = (string.IsNullOrEmpty(fecBaja) || string.IsNullOrWhiteSpace(fecBaja));
                filaTramoModel.Tramo.FechaBaja = SqlDateTime.MinValue.Value;
                
            }
            return filaTramoModel;
        }

        public IFilaTramoModel editarFilaTramoModel(Tramo tramo)
        {
            EditarFilaTramoModel model = new EditarFilaTramoModel();
            model.Tramo = tramo;
            return model;
        }

        public List<IFilaTramoModel> obtenerFilaTramo()
        {
            return new List<IFilaTramoModel>();
        }

        public List<IFilaTramoModel> obtenerFilaTramo(string Codigo)
        {
            ICollection<Tramo> ServicioTramos = obtenerServicioTramos(Codigo);
            List<IFilaTramoModel> Tramos = new List<IFilaTramoModel>();
            foreach (Tramo t in ServicioTramos)
            {
                Tramos.Add(editarFilaTramoModel(t));
            }
            return Tramos;
        }

        public ICollection<Tramo> obtenerServicioTramos(string codServ)
        {
            ICollection<Tramo> servicioTramos = ServicioTramoDAO.ListarServiciosTramos(codServ);
            return servicioTramos;
        }

        public ICollection<Tramo> listarTramosNuevo()
        {
            return TramoDAO.ListarTramos2();
        }

        public ICollection<Ubicacion> listarUbicacionesNuevo()
        {
            return UbicacionDAO.ListarUbicaciones2();
        }

        //desarrollado x VVM
        /////////////////////////////////////////////////////////////////////////////////////
        /////////////////////////////////////////////////////////////////////////////////////
        /// </summary>
        /// <param name="moUbicacion"></param>
        /// 

        //UBICACIONES
        private void guardarUbicacion(Ubicacion moUbicacion)
        {
                    Ubicacion ub = new Ubicacion
                    {
                        Estado = Ubicacion.PENDIENTE,
                        Codigo = moUbicacion.Codigo,
                        FechaCreacion = DateTime.Now,
                        FechaModificacion = DateTime.Now,
                        UsuarioCreado = moUbicacion.UsuarioCreado,
                        UsuarioModificado = moUbicacion.UsuarioModificado
                    };
                    UbicacionDAO.Crear(ub);
        }

        public Ubicacion obtenerUbicacion(string Codigo)
        {
            return UbicacionDAO.Obtener(Codigo);
        }

        public UbicacionesModel actualizarUbicacionModel(string codUbicacion, UbicacionEstadoEnum estado)
        {
            UbicacionesModel model = new UbicacionesModel
            {
                EstadoEdicion = estado,
            };
            if (estado == UbicacionEstadoEnum.EDITAR)
            {
                model.Ubicacion = obtenerUbicacion(codUbicacion);
            }
            return model;
        }

        /// <summary>
        /// </summary>
        /// <param name="moServicio">Modelo Ubicacion</param>
        /// <returns></returns>
        public UbicacionesModel modificarUbicacion(UbicacionesModel moUbicacion)
        {
            if (moUbicacion.EstadoEdicion == UbicacionEstadoEnum.NUEVO)
            {
                throw new CodigoInvalidoException("Operación inválida");
            }
            this.modificarUbicacion(moUbicacion.Ubicacion);
            return moUbicacion;
        }

        public Ubicacion modificarUbicacion(Ubicacion moUbicacion)
        {
            if (moUbicacion.Codigo.Equals(""))
            {
                throw new CodigoInvalidoException("Debe ingresar un código válido");
            }

            Ubicacion edUbicacion = UbicacionDAO.Obtener(moUbicacion.Codigo);
            edUbicacion.Descripcion = moUbicacion.Descripcion;
            edUbicacion.FechaModificacion = DateTime.Now;
            edUbicacion.UsuarioModificado = moUbicacion.UsuarioModificado;
            if (edUbicacion.FechaCreacion == DateTime.MinValue) edUbicacion.FechaCreacion = SqlDateTime.MinValue.Value;
            moUbicacion = UbicacionDAO.Modificar(edUbicacion);
            return edUbicacion;
        }

        public Ubicacion crearUbicacion(Ubicacion toUbicacion)
        {
            if (toUbicacion.Codigo.Equals(""))
            {
                throw new CodigoInvalidoException("Debe ingresar un código válido");
            }
            if (UbicacionDAO.Obtener(toUbicacion.Codigo) != null)
            {
                //ojo verificar nombre de excepciones
                throw new ServicioExistenteException("Código ya existe");
            }
            toUbicacion.Estado = Ubicacion.PENDIENTE;
            toUbicacion.FechaCreacion = DateTime.Now;
            toUbicacion.FechaModificacion = DateTime.Now;
            UbicacionDAO.Crear(toUbicacion);
            guardarUbicacion(toUbicacion);
            return toUbicacion;
        }

        public UbicacionesModel crearUbicacion(UbicacionesModel moUbicacion)
        {
            if (moUbicacion.EstadoEdicion != UbicacionEstadoEnum.NUEVO)
            {
                throw new CodigoInvalidoException("Operación inválida");
            }
            this.crearUbicacion(moUbicacion.Ubicacion);
            return moUbicacion;
        }

        public UbicacionesModel procesarUbicacionesModel(UbicacionesModel model, HttpRequestBase Request, Usuario user)
        {

            //Flujo básico
            if (model.esModeloValido)
            {
                model.Ubicacion.UsuarioCreado = user.Codigo;
                model.Ubicacion.UsuarioModificado = user.Codigo;
                if (model.EstadoEdicion == UbicacionEstadoEnum.NUEVO)
                {
                    crearUbicacion(model);//Crear la ubicacion
                    model.EstadoEdicion = UbicacionEstadoEnum.EDITAR;
                }
                else
                {
                    modificarUbicacion(model);
                }
            }
            return model;
        }

        //TRAMOS
        private void guardarTramo(Tramo moTramo)
        {
            Tramo tr = new Tramo
            {
                Estado = Tramo.PENDIENTE,
                Codigo = moTramo.Codigo,
                FechaCreacion = DateTime.Now,
                FechaModificacion = DateTime.Now,
                Origen = moTramo.Origen,
                Destino = moTramo.Destino,
                UsuarioCreado = moTramo.UsuarioCreado,
                UsuarioModificado = moTramo.UsuarioModificado
            };
            TramoDAO.Crear(tr);
        }
        public Tramo obtenerTramo(string Codigo)
        {
            return TramoDAO.Obtener(Codigo);
        }

        public TramosModel actualizarTramoModel(string codTramo, TramoEstadoEnum estado)
        {
            TramosModel model = new TramosModel
            {
                EstadoEdicion = estado,
            };
            if (estado == TramoEstadoEnum.EDITAR)
            {
                model.Tramo = obtenerTramo(codTramo);
            }
            return model;
        }

        public TramosModel modificarTramo(TramosModel moTramo)
        {
            if (moTramo.EstadoEdicion == TramoEstadoEnum.NUEVO)
            {
                throw new CodigoInvalidoException("Operación inválida");
            }
            this.modificarTramo(moTramo.Tramo);
            return moTramo;
        }

        public Tramo modificarTramo(Tramo moTramo)
        {
            if (moTramo.Codigo.Equals(""))
            {
                throw new CodigoInvalidoException("Debe ingresar un código válido");
            }

            Tramo edTramo = TramoDAO.Obtener(moTramo.Codigo);
            edTramo.Descripcion = moTramo.Descripcion;
            edTramo.Origen = edTramo.Origen;
            edTramo.Destino = edTramo.Destino;
            edTramo.FechaModificacion = DateTime.Now;
            edTramo.UsuarioModificado = moTramo.UsuarioModificado;
            //SE DEFINE FECHA DE BAJA TEMPORALMENTE CON LA FECHA DE HOY. CORREGIR VALOR MINIMO A COLOCAR. O COLOCAR NULL.
            edTramo.FechaBaja = DateTime.Now;
            //if (edTramo.FechaCreacion == DateTime.MinValue) edTramo.FechaCreacion = SqlDateTime.MinValue.Value;
            moTramo = TramoDAO.Modificar(edTramo);
            return edTramo;
        }


        public Tramo crearTramo(Tramo toTramo)
        {
            if (toTramo.Codigo.Equals(""))
            {
                throw new CodigoInvalidoException("Debe ingresar un código válido");
            }
            if (TramoDAO.Obtener(toTramo.Codigo) != null)
            {
                //ojo verificar nombre de excepciones
                throw new ServicioExistenteException("Código ya existe");
            }
            toTramo.Estado = Tramo.PENDIENTE;
            toTramo.FechaCreacion = DateTime.Now;
            toTramo.FechaModificacion = DateTime.Now;
            //SE DEFINE FECHA DE BAJA TEMPORALMENTE CON LA FECHA DE HOY. CORREGIR VALOR MINIMO A COLOCAR. O COLOCAR NULL.
            toTramo.FechaBaja = DateTime.Now;
            TramoDAO.Crear(toTramo);
            guardarTramo(toTramo);
            return toTramo;
        }

        public TramosModel crearTramo(TramosModel moTramo)
        {
            if (moTramo.EstadoEdicion != TramoEstadoEnum.NUEVO)
            {
                throw new CodigoInvalidoException("Operación inválida");
            }
            this.crearTramo(moTramo.Tramo);
            return moTramo;
        }

        public TramosModel procesarTramosModel(TramosModel model, HttpRequestBase Request, Usuario user)
        {

            //Flujo básico
            if (model.esModeloValido)
            {
                model.Tramo.UsuarioCreado = user.Codigo;
                model.Tramo.UsuarioModificado = user.Codigo;
                if (model.EstadoEdicion == TramoEstadoEnum.NUEVO)
                {
                    crearTramo(model);//Crear la ubicacion
                    model.EstadoEdicion = TramoEstadoEnum.EDITAR;
                }
                else
                {
                    modificarTramo(model);
                }
            }
            return model;
        }

        //SECCION PARA APROBAR ENTIDADES
        public void aprobarServicio(AprobarServicioFormModel model)
        {
            foreach (AprobarServicioDetalleModel d in model.Detalle)
            {
                if (d.Marcado)
                {
                    switch (model.TipoServicio)
                    {
                        case 1:
                            ServicioDAO.CambiarEstado(d.Codigo, Servicio.ACTIVO);
                            break;
                        case 2:
                            TramoDAO.CambiarEstado(d.Codigo, Servicio.ACTIVO);
                            break;
                    }
                }
            }
        }

        public AprobarServicioFormModel aprobarServicioFormModel(int tipoServicio)
        {
            AprobarServicioFormModel model = new AprobarServicioFormModel(tipoServicio);
            switch (tipoServicio)
            {
                case 1:
                    ICollection<Servicio> lista1 = ServicioDAO.obtenerListadoPendientes();
                    foreach (Servicio c in lista1)
                    {
                        model.agregarItem(c.Codigo, c.Descripcion, tipoServicio, false);
                    }
                    break;
                case 2:
                    ICollection<Tramo> lista2 = TramoDAO.obtenerListadoPendientes();
                    foreach (Tramo c in lista2)
                    {
                        model.agregarItem(c.Codigo, c.Descripcion, tipoServicio, false);
                    }
                    break;
            }
            return model;
        }

    }
}